﻿#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<malloc.h>
using namespace std;

//int globalVar = 1;
//static int staticGlobalVar = 1;
//void Test()
//{
//	static int staticVar = 1;
//	int localVar = 1;
//	int num1[10] = { 1, 2, 3, 4 };
//	char char2[] = "abcd";
//	const char* pChar3 = "abcd";
//	int* ptr1 = (int*)malloc(sizeof(int) * 4);
//	int* ptr2 = (int*)calloc(4, sizeof(int));
//	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//	free(ptr1);
//	free(ptr3);
//}

//int main()
//{
//	int* p1 = new int;//单个对象
//	int* p2 = new int[10];//数组
//
//	int* p3 = new int(5);//初始化，开辟一个int对象初始化为5
//	int* p4 = new int[10] {1, 2, 3};//初始化，前三个值为1，2，3，后面的值默认给零
//
//	delete p1;//释放
//	delete[] p2;
//	delete p3;
//	delete[] p4;//释放多个对象前加[]
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//	~A()
//	{
//		cout << "~A():" << this << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	//只开空间，不调用构造初始化
//	A* p1 = (A*)malloc(sizeof(A));
//	//开空间，调用构造初始化
//	A* p2 = new A;
//	A* p3 = new A(10);
//	//调用析构函数
//	delete p2;
//	delete p3;
//	return 0;
//}

//struct ListNode
//{
//	ListNode* _next;
//	int _val;
//
//	ListNode(int val)
//		:_next(nullptr)
//		, _val(val)
//	{ }
//};
//int main()
//{
//	ListNode* n1 = new ListNode(1);
//	ListNode* n2 = new ListNode(2);
//	ListNode* n3 = new ListNode(3);
//
//	return 0;
//}

//void func()
//{
//	int i = 1;
//	int* ptr = nullptr;
//	do {
//		if (i == 11105)
//		{
//			int x = 0;
//		}
//
//		ptr = new int[1024 * 1024 ];
//		cout << i++ << ":" << ptr << endl;
//	} while (ptr);
//
//	cout << i++ << ":" << ptr << endl;
//}
//int main()
//{
//	try
//	{
//		func();
//	}
//	catch (const exception& e)
//	{
//		cout << e.what() << endl;
//	}
//		
//	return 0;
//}

///*
//operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
//失败，尝试执行空               间不足应对措施，如果改应对措施用户设置了，则继续申请，否
//则抛异常。
//*/
//void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
//{
//	// try to allocate size bytes
//	void* p;
//	while ((p = malloc(size)) == 0)
//		if (_callnewh(size) == 0)
//		{
//			// report no memory
//			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
//			static const std::bad_alloc nomem;
//			_RAISE(nomem);
//		}
//	return (p);
//}
///*
//operator delete: 该函数最终是通过free来释放空间的
//*/
//void operator delete(void* pUserData)
//{
//	_CrtMemBlockHeader* pHead;
//	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
//	if (pUserData == NULL)
//		return;
//	_mlock(_HEAP_LOCK);  /* block other threads */
//	__TRY
//		        /* get a pointer to memory block header */
//		pHead = pHdr(pUserData);
//	         /* verify block type */
//	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
//	_free_dbg(pUserData, pHead->nBlockUse);
//	__FINALLY
//		_munlock(_HEAP_LOCK);  /* release other threads */
//	__END_TRY_FINALLY
//		return;
//}
///*
//free的实现
//*/
//#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

//class A
//{
//public:
//	A(int a = 0)
//		: _a(a)
//	{
//		cout << "A():" << this << endl;
//	}
//
//	/*~A()
//	{
//		cout << "~A():" << this << endl;
//	}*/
//private:
//	int _a;
//};

//int main()
//{
//	//A* p2 = (A*)operator new(sizeof(A));
//	A* p1 = new A(1);
//	delete p1;
//
//	A* p2 = new A[10];
//	delete[] p2;
//
//	return 0;
//}

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* ptr = (A*)operator new(sizeof(A));
	//显式调用构造函数
	new(ptr)A(1);
	//不允许：ptr->A();

	ptr->~A();
	operator delete(ptr);
	return 0;
}